Pythoni NumPy jõudlus: Vektoriseerimisstrateegiate valdamine globaalses andmeteaduses

NumPy on Pythoni teadusliku arvutuse nurgakivi, pakkudes võimsaid tööriistu massiivide ja maatriksitega töötamiseks. NumPy täieliku potentsiaali rakendamine nõuab aga vektoriseerimise tõhusat mõistmist ja rakendamist. See põhjalik juhend uurib vektoriseerimisstrateegiaid, et optimeerida teie NumPy koodi parema jõudluse saavutamiseks, mis on ülioluline globaalsetes andmeteaduse projektides esinevate üha kasvavate andmekogumite käsitlemisel.

Vektoriseerimise mõistmine

Vektoriseerimine on toimingute tegemise protsess kogu massiivil korraga, selle asemel et itereerida läbi üksikute elementide. See lähenemine vähendab oluliselt täitmisaega, kasutades NumPy optimeeritud C-implementatsioone. See väldib eksplitsiitseid Pythoni tsükleid, mis on Pythoni interpreteeritava olemuse tõttu tuntud oma aegluse poolest. Mõelge sellele kui andmete punkt-punktilt töötlemiselt andmete massilisele töötlemisele.

Hajutamise (Broadcasting) võimsus

Hajutamine on võimas mehhanism, mis võimaldab NumPy'l teostada aritmeetilisi operatsioone erineva kujuga massiividel. NumPy laiendab automaatselt väiksemat massiivi, et see vastaks suurema massiivi kujule, võimaldades elementide kaupa operatsioone ilma eksplitsiitse ümberkujundamise või tsükeldamiseta. See on tõhusa vektoriseerimise jaoks hädavajalik.

Näide:

Kujutage ette, et teil on andmekogum keskmiste kuutemperatuuride kohta mitmes linnas üle maailma. Temperatuurid on Celsiuse kraadides ja salvestatud NumPy massiivi:

            
import numpy as np

temperatures_celsius = np.array([25, 30, 15, 5, -5, 10]) # Näidisandmed

            

              
                Copy
              
            
          

Soovite need temperatuurid teisendada Fahrenheiti kraadideks. Valem on: Fahrenheit = (Celsius * 9/5) + 32.

Kasutades vektoriseerimist ja hajutamist, saate selle teisenduse teha üheainsa koodireaga:

            
temperatures_fahrenheit = (temperatures_celsius * 9/5) + 32
print(temperatures_fahrenheit)

            

              
                Copy
              
            
          

See on palju kiirem kui itereerimine läbi massiivi `temperatures_celsius` ja valemi rakendamine igale elemendile eraldi.

Vektoriseerimistehnikad

Siin on mitu tehnikat, et maksimeerida oma NumPy koodi jõudlust vektoriseerimise abil:

1. Universaalfunktsioonid (UFuncs)

NumPy pakub rikkalikku universaalfunktsioonide (UFuncs) komplekti, mis teostavad massiividele elementide kaupa operatsioone. Need funktsioonid on kõrgelt optimeeritud ja neid tuleks eelistada eksplitsiitsetele tsüklitele alati, kui võimalik. Näited hõlmavad `np.add()`, `np.subtract()`, `np.multiply()`, `np.divide()`, `np.sin()`, `np.cos()`, `np.exp()` ja palju muud.

Näide: Massiivi siinuse arvutamine

            
import numpy as np

angels_degrees = np.array([0, 30, 45, 60, 90])
angels_radians = np.radians(angels_degrees) # Teisenda radiaanideks
sines = np.sin(angels_radians)

print(sines)

            

              
                Copy
              
            
          

Funktsiooni `np.sin()` kasutamine on oluliselt kiirem kui tsükli kirjutamine iga nurga siinuse arvutamiseks.

2. Boole'i indekseerimine

Boole'i indekseerimine võimaldab teil valida massiivist elemente Boole'i tingimuse alusel. See on võimas tehnika andmete filtreerimiseks ja tingimuslike operatsioonide sooritamiseks ilma tsükliteta.

Näide: Andmete valimine läve alusel

Oletame, et teil on andmekogum õhukvaliteedi mõõtmiste kohta erinevatest asukohtadest ja soovite tuvastada asukohad, kus reostuse tase ületab teatud läve.

            
import numpy as np

pollution_levels = np.array([10, 25, 5, 35, 15, 40]) # Näidisandmed
threshold = 30

# Leia asukohad, kus reostuse tase ületab läve
high_pollution_locations = pollution_levels > threshold

print(high_pollution_locations)

# Vali tegelikud reostustasemed nendes asukohtades
high_pollution_values = pollution_levels[high_pollution_locations]
print(high_pollution_values)

            

              
                Copy
              
            
          

See kood tuvastab ja eraldab tõhusalt läve ületavad reostustasemed.

3. Massiivi agregeerimine

NumPy pakub funktsioone massiivide agregeerimiseks, näiteks `np.sum()`, `np.mean()`, `np.max()`, `np.min()`, `np.std()` ja `np.var()`. Need funktsioonid toimivad kogu massiividel ja on kõrgelt optimeeritud.

Näide: Keskmise temperatuuri arvutamine

Jätkates igakuiste temperatuuride näitega, arvutame keskmise temperatuuri kõikides linnades:

            
import numpy as np

temperatures_celsius = np.array([25, 30, 15, 5, -5, 10]) # Näidisandmed
average_temperature = np.mean(temperatures_celsius)

print(average_temperature)

            

              
                Copy
              
            
          

See on väga tõhus viis kogu massiivi keskmise arvutamiseks.

4. Eksplitsiitsete tsüklite vältimine

Nagu varem mainitud, on eksplitsiitsed Pythoni tsüklid võrreldes vektoriseeritud operatsioonidega üldiselt aeglased. Vältige `for` või `while` tsüklite kasutamist alati, kui võimalik. Kasutage selle asemel NumPy sisseehitatud funktsioone ja hajutamise võimalusi.

Näide: Selle asemel (aeglane):

            
import numpy as np

arr = np.array([1, 2, 3, 4, 5])
squared_arr = np.array([0, 0, 0, 0, 0]) # Initsialiseeri

for i in range(len(arr)):
    squared_arr[i] = arr[i]**2

print(squared_arr)

            

              
                Copy
              
            
          

Tehke seda (kiire):

            
import numpy as np

arr = np.array([1, 2, 3, 4, 5])
squared_arr = arr**2

print(squared_arr)

            

              
                Copy
              
            
          

Teine näide on oluliselt kiirem, sest see kasutab vektoriseerimist kõigi massiivi elementide korraga ruutu tõstmiseks.

5. Kohapealsed operatsioonid (In-Place Operations)

Kohapealsed operatsioonid muudavad massiivi otse, ilma uut koopiat loomata. See võib säästa mälu ja parandada jõudlust, eriti suurte andmekogumitega töötades. NumPy pakub paljudele tavalistele operatsioonidele kohapealseid versioone, näiteks `+=`, `-=`, `*=`, ja `/=`. Olge aga ettevaatlik kohapealsete operatsioonide kasutamisel tekkivate kõrvalmõjudega.

Näide: Massiivi elementide kohapealne suurendamine

            
import numpy as np

arr = np.array([1, 2, 3, 4, 5])
arr += 1 # Kohapealne liitmine

print(arr)

            

              
                Copy
              
            
          

See muudab algset `arr` massiivi otse.

6. Funktsiooni `np.where()` kasutamine

`np.where()` on mitmekülgne funktsioon uute massiivide loomiseks tingimuste alusel. See võtab sisendiks tingimuse ja kaks massiivi. Kui tingimus on elemendi jaoks tõene, kasutatakse vastavat elementi esimesest massiivist; vastasel juhul kasutatakse elementi teisest massiivist.

Näide: Väärtuste asendamine tingimuse alusel

Kujutage ette, et teil on andmekogum, mis sisaldab andurite näiteid, ja mõned näidud on vigade tõttu negatiivsed. Soovite asendada kõik negatiivsed näidud nulliga.

            
import numpy as np

sensor_readings = np.array([10, -5, 20, -2, 15]) # Näidisandmed

# Asenda negatiivsed näidud 0-ga
corrected_readings = np.where(sensor_readings < 0, 0, sensor_readings)

print(corrected_readings)

            

              
                Copy
              
            
          

See asendab tõhusalt kõik negatiivsed väärtused nulliga.

7. Mälu paigutus ja järjepidevus

Viis, kuidas NumPy massiivid mällu salvestatakse, võib jõudlust oluliselt mõjutada. Järjepidevad massiivid, kus elemendid on salvestatud järjestikustesse mälukohtadesse, toovad üldiselt kaasa kiirema juurdepääsu. NumPy pakub funktsioone nagu `np.ascontiguousarray()`, et tagada massiivi järjepidevus. Operatsioonide teostamisel eelistab NumPy C-stiilis järjepidevust (reapõhine järjestus), kuid mõnel juhul saab kasutada ka Fortrani-stiilis järjepidevust (veerupõhine järjestus).

Näide: Järjepideva massiivi kontrollimine ja teisendamine

            
import numpy as np

arr = np.array([[1, 2], [3, 4]])

print(arr.flags['C_CONTIGUOUS'])

arr_transposed = arr.T # Transponeeri massiiv

print(arr_transposed.flags['C_CONTIGUOUS'])

arr_contiguous = np.ascontiguousarray(arr_transposed)
print(arr_contiguous.flags['C_CONTIGUOUS'])

            

              
                Copy
              
            
          

Massiivi transponeerimine annab sageli tulemuseks mittejärjepideva massiivi. Funktsiooni `np.ascontiguousarray()` kasutamine lahendab selle.

Profileerimine ja jõudluse testimine

Enne koodi optimeerimist on oluline tuvastada jõudlusprobleemid. Profileerimisvahendid aitavad teil tuvastada koodi osad, mis kulutavad kõige rohkem aega. Jõudluse testimine võimaldab teil võrrelda erinevate implementatsioonide jõudlust.

Funktsiooni `%timeit` kasutamine Jupyter Notebookis

Jupyter Notebook pakub maagiakäsku `%timeit` ühe koodirea täitmisaja mõõtmiseks. See on kiire ja lihtne viis erinevate vektoriseerimisstrateegiate jõudluse võrdlemiseks.

Näide: Tsükli ja vektoriseeritud liitmise võrdlemine

            
import numpy as np

arr = np.random.rand(1000000)

# Tsüklipõhine liitmine
def loop_addition(arr):
    result = np.zeros_like(arr)
    for i in range(len(arr)):
        result[i] = arr[i] + 1
    return result

# Vektoriseeritud liitmine
def vectorized_addition(arr):
    return arr + 1

# Jõudluse testimine %timeit abil
# %timeit loop_addition(arr)
# %timeit vectorized_addition(arr)

            

              
                Copy
              
            
          

Käivitage need `%timeit` käsud oma Jupyter Notebookis. Näete selgelt vektoriseeritud lähenemise jõudluse eelist.

Funktsiooni `cProfile` kasutamine

`cProfile` moodul pakub üksikasjalikumat profileerimisteavet, sealhulgas igas funktsioonikutses kulutatud aega.

Näide: Funktsiooni profileerimine

            
import cProfile
import numpy as np

def my_function():
    arr = np.random.rand(1000000)
    result = np.sin(arr) # Näidisoperatsioon
    return result

# Profileeri funktsioon
cProfile.run('my_function()')

            

              
                Copy
              
            
          

See väljastab üksikasjaliku aruande, mis näitab igas funktsioonis (`my_function()` piires) kulutatud aega. See aitab tuvastada optimeerimisvõimalusi.

Reaalse maailma näited ja globaalsed kaalutlused

Vektoriseerimine on oluline erinevates andmeteaduse rakendustes, sealhulgas:

• Pilditöötlus: Toimingute teostamine tervetel piltidel (esitatud NumPy massiividena) ülesannete jaoks, nagu filtreerimine, servade tuvastamine ja pildi täiustamine. Näiteks teravustamisfiltri rakendamine Euroopa Kosmoseagentuuri Sentinel missioonide satelliidipiltidele.
• Masinõpe: Masinõppe algoritmide rakendamine vektoriseeritud operatsioone kasutades kiiremaks treenimiseks ja ennustamiseks. Näiteks gradiendi languse uuenduse arvutamine lineaarse regressioonimudeli jaoks, kasutades suurt andmekogumit globaalse e-kaubanduse platvormi klienditehingutest.
• Finantsmodelleerimine: Simulatsioonide ja arvutuste teostamine suurte finantsandmete kogumite (nt aktsiahinnad või optsioonihinnad) kohta. Aktsiaturu andmete analüüsimine erinevatelt börsidelt (nt NYSE, LSE, TSE) arbitraaživõimaluste tuvastamiseks.
• Teaduslikud simulatsioonid: Füüsikaliste süsteemide simulatsioonide käivitamine, näiteks ilmastiku ennustamine või vedelike dünaamika. Kliimamuutuste stsenaariumide simuleerimine globaalsete kliimamudelite abil.

Globaalsete andmekogumitega töötades arvestage järgmiste aspektidega:

• Andmevormingud: Olge teadlik erinevates piirkondades kasutatavatest erinevatest andmevormingutest. Kasutage teekaid nagu `pandas` erinevate failikodeeringute ja kuupäevavormingute käsitlemiseks.
• Ajavööndid: Ajaseeria andmete analüüsimisel arvestage erinevate ajavöönditega. Kasutage teekaid nagu `pytz` ajavööndite vahel teisendamiseks.
• Valuutad: Käsitsege finantsandmetega töötades erinevaid valuutasid. Kasutage API-sid valuutade vahel teisendamiseks.
• Kultuurilised erinevused: Olge andmete tõlgendamisel teadlik kultuurilistest erinevustest. Näiteks võivad erinevatel kultuuridel olla erinevad riskitajud või erinevad eelistused toodete ja teenuste osas.

Täiustatud vektoriseerimistehnikad

NumPy funktsioon `einsum`

`np.einsum` (Einsteini summeerimine) on võimas funktsioon, mis pakub lühikest viisi paljude tavaliste massiivioperatsioonide väljendamiseks, sealhulgas maatriksi korrutamine, jälg, summa mööda telgi ja palju muud. Kuigi selle õppimiskõver võib olla järsem, võib `einsum`i valdamine viia keerukate operatsioonide puhul märkimisväärse jõudluse paranemiseni.

Näide: Maatriksi korrutamine `einsum` abil

            
import numpy as np

A = np.random.rand(3, 4)
B = np.random.rand(4, 5)

# Maatriksi korrutamine einsum abil
C = np.einsum('ij,jk->ik', A, B)

# Samaväärne:
# C = np.matmul(A, B)

print(C.shape)

            

              
                Copy
              
            
          

String `'ij,jk->ik'` määrab sisendmassiivide ja väljundmassiivi indeksid. `i`, `j` ja `k` tähistavad massiivide dimensioone. `ij,jk` näitab, et korrutame massiive `A` ja `B` mööda `j` dimensiooni ning `->ik` näitab, et väljundmassiivil `C` peaksid olema dimensioonid `i` ja `k`.

NumExpr

NumExpr on teek, mis hindab NumPy massiive hõlmavaid numbrilisi avaldisi. See suudab automaatselt avaldisi vektoriseerida ja kasutada ära mitmetuumalisi protsessoreid, mille tulemuseks on sageli märkimisväärne kiirendus. See on eriti kasulik keerukate avaldiste puhul, mis hõlmavad paljusid aritmeetilisi operatsioone.

Näide: NumExpr'i kasutamine keerulise arvutuse jaoks

            
import numpy as np
import numexpr as ne

a = np.random.rand(1000000)
b = np.random.rand(1000000)
c = np.random.rand(1000000)

# Arvuta keeruline avaldis NumExpr'i abil
result = ne.evaluate('a * b + c**2')

# Samaväärne:
# result = a * b + c**2

            

              
                Copy
              
            
          

NumExpr võib olla eriti kasulik avaldiste puhul, mis muidu hõlmaksid paljude vahepealsete massiivide loomist.

Numba

Numba on just-in-time (JIT) kompilaator, mis suudab Pythoni koodi tõlkida optimeeritud masinakoodiks. Seda kasutatakse sageli numbriliste arvutuste kiirendamiseks, eriti nende tsüklite puhul, mida ei saa NumPy sisseehitatud funktsioonide abil kergesti vektoriseerida. Kaunistades oma Pythoni funktsioone `@njit`, saab Numba need kompileerida töötama C või Fortrani omaga võrreldavatel kiirustel.

Näide: Numba kasutamine tsükli kiirendamiseks

            
import numpy as np
from numba import njit

@njit
def calculate_sum(arr):
    total = 0.0
    for i in range(arr.size):
        total += arr[i]
    return total

arr = np.random.rand(1000000)
result = calculate_sum(arr)
print(result)

            

              
                Copy
              
            
          

Numba on eriti tõhus funktsioonide kiirendamiseks, mis hõlmavad eksplitsiitseid tsükleid ja keerulisi numbrilisi arvutusi. Esimest korda funktsiooni kutsudes kompileerib Numba selle. Järgmised kutsungid on palju kiiremad.

Parimad tavad globaalseks koostööks

Andmeteaduse projektidega globaalses meeskonnas töötades kaaluge järgmisi parimaid tavasid:

• Versioonihaldus: Kasutage versioonihaldussüsteemi nagu Git, et jälgida oma koodi ja andmete muudatusi. See võimaldab meeskonnaliikmetel tõhusalt koostööd teha ja vältida konflikte.
• Koodi ülevaatused: Viige läbi koodi ülevaatused, et tagada koodi kvaliteet ja järjepidevus. See aitab tuvastada potentsiaalseid vigu ja parandada koodi üldist disaini.
• Dokumentatsioon: Kirjutage oma koodi ja andmete kohta selge ja kokkuvõtlik dokumentatsioon. See teeb teistele meeskonnaliikmetele teie töö mõistmise ja projekti panustamise lihtsamaks.
• Testimine: Kirjutage ühiktestid, et tagada koodi korrektne toimimine. See aitab vältida regressioone ja tagada koodi töökindluse.
• Suhtlus: Kasutage tõhusaid suhtlusvahendeid oma meeskonnaliikmetega ühenduses püsimiseks. See aitab tagada, et kõik on samal lehel ja kõik probleemid lahendatakse kiiresti. Tööriistad nagu Slack, Microsoft Teams ja Zoom on globaalseks koostööks hädavajalikud.
• Taasesitatavus: Kasutage tööriistu nagu Docker või Conda, et luua taasesitatavaid keskkondi. See tagab, et teie kood töötab järjepidevalt erinevatel platvormidel ja keskkondades. See on ülioluline oma töö jagamisel koostööpartneritega, kellel võivad olla erinevad tarkvarakonfiguratsioonid.
• Andmehaldus: Kehtestage selged andmehalduse põhimõtted, et tagada andmete eetiline ja vastutustundlik kasutamine. See on eriti oluline tundlike andmetega töötamisel.

Järeldus

Vektoriseerimise valdamine on tõhusa ja suure jõudlusega NumPy koodi kirjutamiseks ülioluline. Mõistes ja rakendades selles juhendis käsitletud tehnikaid, saate oluliselt kiirendada oma andmeteaduse töövooge ning lahendada suuremaid ja keerukamaid probleeme. Globaalsete andmeteaduse projektide puhul tähendab NumPy jõudluse optimeerimine otseselt kiiremaid teadmisi, paremaid mudeleid ja lõppkokkuvõttes suurema mõjuga lahendusi. Pidage meeles oma koodi profileerida, võrrelda erinevaid lähenemisi ja valida oma konkreetsetele vajadustele kõige paremini sobivad vektoriseerimistehnikad. Arvestage globaalsete kaalutlustega andmevormingute, ajavööndite, valuutade ja kultuuriliste erinevuste osas. Nende parimate tavade rakendamisega saate luua suure jõudlusega andmeteaduse lahendusi, mis on valmis lahendama globaliseerunud maailma väljakutseid.

Nende strateegiate mõistmise ja nende oma töövoogu integreerimisega saate oluliselt parandada oma NumPy-põhiste andmeteaduse projektide jõudlust, tagades, et saate tõhusalt töödelda ja analüüsida andmeid globaalsel tasandil. Pidage meeles alati oma koodi profileerida ja katsetada erinevate tehnikatega, et leida oma konkreetse probleemi jaoks optimaalne lahendus.